Skip to content

⚡️ Speed up function manual_convolution_1d by 230% #103

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

⚡️ Speed up function manual_convolution_1d by 230% #103

wants to merge 1 commit into from

Conversation

codeflash-ai[bot]
Copy link

@codeflash-ai codeflash-ai bot commented Sep 10, 2025

📄 230% (2.30x) speedup for manual_convolution_1d in src/numpy_pandas/signal_processing.py

⏱️ Runtime : 11.0 milliseconds → 3.32 milliseconds (best of 309 runs)

📝 Explanation and details

The optimization replaces the nested Python loops with NumPy's vectorized np.dot operation. Instead of manually iterating through each kernel element and accumulating signal[i + j] * kernel[j], the code now uses np.dot(signal[i:i + kernel_len], kernel) to compute the dot product directly.

Key changes:

  • Eliminated the inner for j in range(kernel_len) loop that was consuming 61.4% of execution time
  • Replaced manual element-wise multiplication and accumulation with NumPy's optimized np.dot
  • Array slicing signal[i:i + kernel_len] creates the appropriate signal window for each convolution step

Why this is faster:
NumPy's np.dot uses highly optimized C/BLAS implementations that can leverage SIMD instructions and avoid Python's interpretation overhead. The original nested loops required ~75,909 Python operations, while the optimized version performs the same computation with ~8,030 vectorized operations.

Performance characteristics:

  • Small inputs (kernel size 1-3): Shows 20-50% slowdown due to NumPy function call overhead
  • Medium inputs (kernel size 5-20): Neutral to modest gains
  • Large inputs (kernel size 20+, signal 1000+): Massive speedups of 250-700% as vectorization benefits outweigh overhead

This optimization is most effective for larger convolution problems where the computational savings from vectorized operations significantly exceed the function call overhead.

✅ Correctness verification report:

Test Status
⚙️ Existing Unit Tests 🔘 None Found
🌀 Generated Regression Tests ✅ 40 Passed
⏪ Replay Tests 🔘 None Found
🔎 Concolic Coverage Tests 🔘 None Found
📊 Tests Coverage 100.0%
🌀 Generated Regression Tests and Runtime 
import numpy as np
# imports
import pytest  # used for our unit tests
from src.numpy_pandas.signal_processing import manual_convolution_1d

# unit tests

# -------------------- Basic Test Cases --------------------

def test_basic_identity_kernel():
    # Convolution with kernel [1] returns the original signal
    signal = np.array([1, 2, 3, 4, 5])
    kernel = np.array([1])
    expected = np.array([1, 2, 3, 4, 5])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.92μs -> 3.96μs (51.6% slower)

def test_basic_simple_sum():
    # Convolution with kernel [1, 1] computes sliding sum of pairs
    signal = np.array([1, 2, 3, 4])
    kernel = np.array([1, 1])
    expected = np.array([3, 5, 7])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.00μs -> 2.79μs (28.4% slower)

def test_basic_weighted_kernel():
    # Convolution with kernel [2, 0] doubles the first value in each window
    signal = np.array([1, 2, 3, 4])
    kernel = np.array([2, 0])
    expected = np.array([2, 4, 6])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.00μs -> 2.75μs (27.3% slower)

def test_basic_negative_kernel():
    # Convolution with kernel [-1, 1] computes discrete difference
    signal = np.array([5, 6, 9, 10])
    kernel = np.array([-1, 1])
    expected = np.array([1, 3, 1])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.00μs -> 2.71μs (26.1% slower)

def test_basic_float_signal_and_kernel():
    # Test with floating point values
    signal = np.array([0.5, 1.5, 2.5])
    kernel = np.array([1.0, 0.5])
    expected = np.array([0.5*1.0 + 1.5*0.5, 1.5*1.0 + 2.5*0.5])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.50μs -> 1.88μs (20.0% slower)

def test_basic_kernel_longer_than_one():
    # Test with kernel of length 3
    signal = np.array([1, 2, 3, 4, 5])
    kernel = np.array([1, 0, -1])
    expected = np.array([
        1*1 + 2*0 + 3*(-1),
        2*1 + 3*0 + 4*(-1),
        3*1 + 4*0 + 5*(-1)
    ])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.54μs -> 2.79μs (8.96% slower)

# -------------------- Edge Test Cases --------------------

def test_edge_kernel_equals_signal_length():
    # Kernel same length as signal: result is a single value
    signal = np.array([1, 2, 3])
    kernel = np.array([4, 5, 6])
    expected = np.array([1*4 + 2*5 + 3*6])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.38μs -> 1.58μs (13.1% slower)

def test_edge_kernel_length_one():
    # Kernel of length 1 should return the original signal
    signal = np.array([7, 8, 9])
    kernel = np.array([2])
    expected = np.array([14, 16, 18])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.46μs -> 2.75μs (47.0% slower)

def test_edge_signal_length_one():
    # Signal of length 1, kernel of length 1
    signal = np.array([42])
    kernel = np.array([3])
    expected = np.array([126])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 958ns -> 1.58μs (39.5% slower)

def test_edge_empty_signal():
    # Empty signal should raise ValueError
    signal = np.array([])
    kernel = np.array([1, 2])
    with pytest.raises(ValueError):
        manual_convolution_1d(signal, kernel) # 667ns -> 625ns (6.72% faster)




def test_edge_multidimensional_input():
    # Multidimensional input should raise ValueError
    signal = np.array([[1, 2], [3, 4]])
    kernel = np.array([1, 2])
    with pytest.raises(ValueError):
        manual_convolution_1d(signal, kernel)
    signal = np.array([1, 2, 3])
    kernel = np.array([[1], [2]])
    with pytest.raises(ValueError):
        manual_convolution_1d(signal, kernel)

def test_edge_different_dtypes():
    # Test with integer signal and float kernel
    signal = np.array([1, 2, 3, 4], dtype=int)
    kernel = np.array([0.5, 1.5], dtype=float)
    expected = np.array([
        1*0.5 + 2*1.5,
        2*0.5 + 3*1.5,
        3*0.5 + 4*1.5
    ])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.50μs -> 3.12μs (20.0% slower)

def test_edge_negative_values():
    # Test with negative values in signal and kernel
    signal = np.array([-1, -2, -3])
    kernel = np.array([-1, 2])
    expected = np.array([-1*-1 + -2*2, -2*-1 + -3*2])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.67μs -> 2.38μs (29.8% slower)

def test_edge_zero_kernel():
    # Kernel of all zeros should return all zeros
    signal = np.array([1, 2, 3, 4])
    kernel = np.array([0, 0])
    expected = np.array([0, 0, 0])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.04μs -> 2.79μs (26.9% slower)

def test_edge_zero_signal():
    # Signal of all zeros should return all zeros
    signal = np.zeros(5)
    kernel = np.array([1, 2])
    expected = np.zeros(4)
    codeflash_output = manual_convolution_1d(signal, np.array([1])); result = codeflash_output # 1.92μs -> 4.21μs (54.5% slower)
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.88μs -> 2.67μs (29.7% slower)

# -------------------- Large Scale Test Cases --------------------

def test_large_scale_random_signal_and_kernel():
    # Test with large random arrays
    rng = np.random.default_rng(42)
    signal = rng.random(1000)
    kernel = rng.random(10)
    # Use numpy's convolve for reference (valid mode)
    expected = np.convolve(signal, kernel, mode='valid')
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.53ms -> 378μs (304% faster)

def test_large_scale_all_ones():
    # Signal and kernel both all ones
    signal = np.ones(1000)
    kernel = np.ones(10)
    expected = np.full(1000 - 10 + 1, 10.0)
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.53ms -> 378μs (305% faster)

def test_large_scale_increasing_signal():
    # Signal is increasing, kernel is decreasing
    signal = np.arange(1, 1001)
    kernel = np.arange(10, 0, -1)
    # Reference: numpy's convolve
    expected = np.convolve(signal, kernel, mode='valid')
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.76ms -> 492μs (258% faster)

def test_large_scale_kernel_length_one():
    # Large signal, kernel of length 1
    signal = np.random.random(1000)
    kernel = np.array([2.5])
    expected = signal * 2.5
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 182μs -> 381μs (52.1% slower)

def test_large_scale_kernel_equals_signal_length():
    # Both signal and kernel of length 1000
    signal = np.arange(1000)
    kernel = np.arange(1000)
    expected = np.array([np.dot(signal, kernel)])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 178μs -> 1.92μs (9214% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import numpy as np
# imports
import pytest  # used for our unit tests
from src.numpy_pandas.signal_processing import manual_convolution_1d

# unit tests

# ----------------
# BASIC TEST CASES
# ----------------

def test_simple_identity_kernel():
    # Identity kernel should return the input signal (for kernel=[1])
    signal = np.array([1, 2, 3, 4, 5])
    kernel = np.array([1])
    expected = np.array([1, 2, 3, 4, 5])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.96μs -> 4.00μs (51.0% slower)

def test_simple_average_kernel():
    # Kernel [0.5, 0.5] computes the moving average of length 2
    signal = np.array([2, 4, 6, 8])
    kernel = np.array([0.5, 0.5])
    expected = np.array([3, 5, 7])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.38μs -> 3.00μs (20.8% slower)

def test_kernel_longer_than_one():
    # Kernel [1, 2] applied to [1, 2, 3]
    signal = np.array([1, 2, 3])
    kernel = np.array([1, 2])
    # [1*1 + 2*2, 2*1 + 3*2] = [1+4, 2+6] = [5, 8]
    expected = np.array([5, 8])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.62μs -> 2.25μs (27.8% slower)

def test_negative_values():
    # Test with negative values in signal and kernel
    signal = np.array([1, -2, 3])
    kernel = np.array([-1, 2])
    # [1*-1 + -2*2, -2*-1 + 3*2] = [-1-4, 2+6] = [-5, 8]
    expected = np.array([-5, 8])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.62μs -> 2.21μs (26.4% slower)

def test_float_and_int_mix():
    # Test with float signal and int kernel
    signal = np.array([1.5, 2.5, 3.5])
    kernel = np.array([2, 0])
    # [1.5*2 + 2.5*0, 2.5*2 + 3.5*0] = [3.0, 5.0]
    expected = np.array([3.0, 5.0])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.67μs -> 2.33μs (28.5% slower)

# ----------------
# EDGE TEST CASES
# ----------------

def test_kernel_length_equals_signal_length():
    # Should return a single value (dot product)
    signal = np.array([1, 2, 3])
    kernel = np.array([4, 5, 6])
    expected = np.array([1*4 + 2*5 + 3*6])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.42μs -> 1.58μs (10.6% slower)




def test_non_1d_signal_raises():
    # Non-1D signal should raise ValueError
    signal = np.array([[1, 2], [3, 4]])
    kernel = np.array([1, 2])
    with pytest.raises(ValueError):
        manual_convolution_1d(signal, kernel) # 3.46μs -> 2.17μs (59.6% faster)

def test_non_1d_kernel_raises():
    # Non-1D kernel should raise ValueError
    signal = np.array([1, 2, 3])
    kernel = np.array([[1, 2]])
    with pytest.raises(ValueError):
        manual_convolution_1d(signal, kernel) # 2.96μs -> 2.04μs (44.9% faster)


def test_signal_with_zeros():
    # Signal with zeros, kernel with ones
    signal = np.array([0, 0, 0, 0])
    kernel = np.array([1, 1])
    expected = np.array([0, 0, 0])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.12μs -> 3.04μs (30.1% slower)

def test_kernel_with_zeros():
    # Kernel with zeros, signal with ones
    signal = np.array([1, 1, 1, 1])
    kernel = np.array([0, 0])
    expected = np.array([0, 0, 0])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.04μs -> 2.88μs (29.0% slower)

def test_signal_and_kernel_all_zeros():
    # Both signal and kernel are zeros
    signal = np.zeros(5)
    kernel = np.zeros(3)
    expected = np.zeros(3)
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.33μs -> 2.42μs (3.44% slower)

def test_kernel_with_one_negative():
    # Kernel with one negative value
    signal = np.array([1, 2, 3, 4])
    kernel = np.array([1, -1])
    # [1*1 + 2*-1, 2*1 + 3*-1, 3*1 + 4*-1] = [1-2, 2-3, 3-4] = [-1, -1, -1]
    expected = np.array([-1, -1, -1])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 2.04μs -> 2.83μs (28.0% slower)

def test_signal_and_kernel_with_large_values():
    # Large values to check for overflow/precision
    signal = np.array([1e10, -1e10, 1e10])
    kernel = np.array([1e10, 1])
    expected = np.array([1e10*1e10 + -1e10*1, -1e10*1e10 + 1e10*1])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.50μs -> 1.83μs (18.2% slower)

# ---------------------
# LARGE SCALE TEST CASES
# ---------------------

def test_large_signal_and_kernel():
    # Large signal and kernel, but under 1000 elements
    np.random.seed(42)
    signal = np.random.rand(1000)
    kernel = np.random.rand(20)
    # Compare with numpy's built-in convolution (valid mode)
    expected = np.convolve(signal, kernel, mode='valid')
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 3.01ms -> 376μs (701% faster)

def test_large_kernel_size_one():
    # Large signal, kernel of size 1 (should return signal)
    signal = np.random.rand(999)
    kernel = np.array([1.0])
    expected = signal.copy()
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 182μs -> 376μs (51.5% slower)

def test_large_kernel_size_equals_signal():
    # Both signal and kernel have the same large size
    signal = np.arange(500, dtype=np.float64)
    kernel = np.arange(500, dtype=np.float64)
    expected = np.array([np.dot(signal, kernel)])
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 76.8μs -> 1.33μs (5660% faster)

def test_large_kernel_all_ones():
    # Moving sum over large signal
    signal = np.ones(1000)
    kernel = np.ones(10)
    expected = np.convolve(signal, kernel, mode='valid')
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 1.53ms -> 372μs (311% faster)

def test_large_signal_with_pattern():
    # Signal with repeating pattern, kernel with alternating sign
    signal = np.tile([1, 2, 3, 4, 5], 200)  # length 1000
    kernel = np.array([1, -1, 1, -1, 1])
    expected = np.convolve(signal, kernel, mode='valid')
    codeflash_output = manual_convolution_1d(signal, kernel); result = codeflash_output # 908μs -> 487μs (86.4% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from src.numpy_pandas.signal_processing import manual_convolution_1d

To edit these changes git checkout codeflash/optimize-manual_convolution_1d-mfel6ojo and push.

Codeflash

@codeflash-ai
Optimize manual_convolution_1d
b265fbc 
The optimization replaces the nested Python loops with NumPy's vectorized `np.dot` operation. Instead of manually iterating through each kernel element and accumulating `signal[i + j] * kernel[j]`, the code now uses `np.dot(signal[i:i + kernel_len], kernel)` to compute the dot product directly.

**Key changes:**
- Eliminated the inner `for j in range(kernel_len)` loop that was consuming 61.4% of execution time
- Replaced manual element-wise multiplication and accumulation with NumPy's optimized `np.dot`
- Array slicing `signal[i:i + kernel_len]` creates the appropriate signal window for each convolution step

**Why this is faster:**
NumPy's `np.dot` uses highly optimized C/BLAS implementations that can leverage SIMD instructions and avoid Python's interpretation overhead. The original nested loops required ~75,909 Python operations, while the optimized version performs the same computation with ~8,030 vectorized operations.

**Performance characteristics:**
- **Small inputs** (kernel size 1-3): Shows 20-50% slowdown due to NumPy function call overhead
- **Medium inputs** (kernel size 5-20): Neutral to modest gains  
- **Large inputs** (kernel size 20+, signal 1000+): Massive speedups of 250-700% as vectorization benefits outweigh overhead

This optimization is most effective for larger convolution problems where the computational savings from vectorized operations significantly exceed the function call overhead.
@codeflash-ai codeflash-ai bot requested a review from aseembits93 September 10, 2025 23:04
@codeflash-ai codeflash-ai bot added the ⚡️ codeflash Optimization PR opened by Codeflash AI label Sep 10, 2025
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@aseembits93 aseembits93 Awaiting requested review from aseembits93

At least 1 approving review is required to merge this pull request.

Assignees

No one assigned

Labels

⚡️ codeflash Optimization PR opened by Codeflash AI

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

0 participants